package com.example.service.impl;

import com.example.Utils.lookUpUtils;
import com.example.mapper.repairBookMapp;
import com.example.mapper.repairTestingMapp;
import com.example.pojo.Result;
import com.example.pojo.ThreeList;
import com.example.pojo.repairBookPojo;
import com.example.service.repairBookService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.*;

/**
 * ClassName:repairBookImpl
 * Description:
 *
 */
@Service//注解：表示把这个注入到了ben中。
@Slf4j//可以输出注解
public class repairBookImpl implements repairBookService {
    @Autowired
    private repairBookMapp repairBookMapp;
    @Autowired
    private repairTestingMapp repairTestingMapp;
    @Value("${file.upload-dir}")
    private String fileSaveLocation;
    @Override
    public List<repairBookPojo> list(String workshop, String taksName,String languageS) {
        //判断用户传过来的是那个语言，然后根据这个语言记录的字段查询

        List<repairBookPojo> repairBookPojoList =new ArrayList<>();
        if (Objects.equals(languageS, "chinese")){
            return repairBookMapp.list(workshop, taksName,"workshop","taksName");
        } else if (Objects.equals(languageS, "english")) {
            return repairBookMapp.list(workshop, taksName,"workshopEnglish","taksNameEnglish");
        } else if (Objects.equals(languageS, "russian")) {
            return repairBookMapp.list(workshop, taksName,"workshopRussian","taksNameRussian");
        }else {
            return repairBookPojoList;
        }
    }


    //查找数据库中的车间、返工返修指导书名称，形成页面的树型导航栏
    @Override
    public List<ThreeList> TreeList() {
        //新建一个list，作为返回值，存放目录的信息；
        List<ThreeList>[] lists = new List[3];
        //查询出中文的导航数据
        List<ThreeList> TreeAll = new ArrayList<>();

        List<String> TreeOne = repairBookMapp.OneOneStr("workshopEnglish");
        log.info("看看筛选出的一级目录{}",TreeOne.toString());
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = repairBookMapp.findDistinctBValuesByA("taksNameEnglish", "workshopEnglish", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                ThreeList rootTow = new ThreeList();
                 rootTow.setLabel(TreeTow.get(j));
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把英文的列表记录下来
        lists[0]=TreeAll;
        //查询出英文的导航数据
        TreeOne = repairBookMapp.OneOneStr("workShop");
        log.info("看看筛选出的一级目录{}",TreeOne.toString());
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = repairBookMapp.findDistinctBValuesByA("taksName", "workshop", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                ThreeList rootTow = new ThreeList();
                rootTow.setLabel(TreeTow.get(j));
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把中文的列表记录下来
        lists[1]=TreeAll;
        //查询出俄语的导航数据
        TreeOne = repairBookMapp.OneOneStr("workshopRussian");
        log.info("看看筛选出的一级目录{}",TreeOne.toString());
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = repairBookMapp.findDistinctBValuesByA("taksNameRussian", "workshopRussian", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                ThreeList rootTow = new ThreeList();
                rootTow.setLabel(TreeTow.get(j));
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把俄文的列表记录下来
        lists[2]=TreeAll;
        return TreeAll;
    }
    @Override
    //修改返工返修作业指导书中的“操作步骤”、图片内容,用在了内容也修改，图片有增加、或者替换的。
    public repairBookPojo repairModifySteps(String tableDataTempJson, List<MultipartFile> fileListV) throws JsonProcessingException {
        //定义一个图片文件名的字符串，记录保存的文件名。
       String fileNameAll="";
       // 定义文件保存的目录（这里假设是服务器的/Server目录）
//       String saveDir = "D:\\new\\Server\\";
        String saveDir=fileSaveLocation;
        try{
            //把接收到的字符串数据更换为对象
            repairBookPojo tableDataTemp = new ObjectMapper().readValue(tableDataTempJson,repairBookPojo.class);
            //把传递出来的数据，不需要修改的文件名记录下来
            String fileNameB=tableDataTemp.getFileNameAll();
            //根据传入的ID，把数据库中原来的文件记录信息找出来，作为对比是否是一个重复的文件。
            String fileNameAllOld= repairBookMapp.lookUpId(tableDataTemp.getId(),"fileNameAll");
            //第一步：首先实现文件删除功能
            if (fileNameAllOld!=null){
                //识别出那个文件需要删除，把老的图片文件名信息中需要保留的信息删除掉。
                String deleteFile=fileNameAllOld.replace(tableDataTemp.getFileNameAll(),"");
                if (deleteFile!=""){
                    String[] deleteFileItem=deleteFile.split("\\|\\*\\|");
                    log.info(Arrays.toString(deleteFileItem));
                    //循环，对需要删除的文件进行删除。
                    for (int i = 0; i < deleteFileItem.length; i++) {
                        // 构建文件的完整路径
                        String filePath = saveDir + File.separator + deleteFileItem[i];
                        //创建需要删除的这个文件
                        File file = new File(filePath);
                        //检查文件是否存在,存在的时候进行操作，不存在就不处理了
                        if(file.exists()){
                            log.info("文件找到了");
                            // 检查是否是文件而不是目录，如果是目录，就不处理了。
                            if (file.isFile()) {
                                // 检查是否有删除权限,有修改权限的时候才进行删除，没有权限就不处理了
                                if (file.canWrite()) {
                                    log.info("文件有修改权限");
                                    //删除文件
                                    boolean isDeleted = file.delete();
                                    if (isDeleted) {
                                        log.info("删除成功，文件名是：{}",filePath);
                                    } else {
                                        log.info("删除识别，需要删除的文件是：{}",filePath);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            //第二步：对新加入的文件进行更新，保存。
            if (fileListV != null && !fileListV.isEmpty()) {
                File dir = new File(saveDir);
                // 如果目录不存在，则创建它
                if (!dir.exists()) {
                    dir.mkdirs();
                }
                // 遍历文件列表并保存每个文件
                for (MultipartFile file : fileListV) {
                    if (!file.isEmpty()) {
                        try {
                            // 生成文件的唯一名称以避免冲突
                            String fileName = UUID.randomUUID()+"&&"+file.getOriginalFilename();
                            String filePath = saveDir + fileName;
                            File dest = new File(filePath);
                            // 将文件保存到服务器上的指定位置
                            file.transferTo(dest);
                            fileNameAll=fileNameAll+fileName+"|*|";
                        } catch (IOException e) {
                            throw new RuntimeException("文件保存失败：" + e.getMessage());
                        }
                    }
                }
            } else {
                log.warn("没有接收到文件");
            }
            //组合新的数据库信息,只写入文件名的数据，其他不写入。
            tableDataTemp.setFileNameAll(fileNameB+fileNameAll);
            tableDataTemp.setUpdateTime(LocalDateTime.now());
            repairBookMapp.updateOnlyFileName(tableDataTemp);
            return tableDataTemp;
        } catch (IOException e){
            e.printStackTrace();
        }
        return new repairBookPojo();
    }
    /*用在传输操作说明中的内容更改后，对数据库的内容进行更新用*/
    @Override
    public void repairModifyString(repairBookPojo repairBookPojo){
        repairBookMapp.update(repairBookPojo);
    }

    /* 通过ID，查询某一个字段中的值，返回在通用结果中的是一个字符串*/
    @Override
    public String lookupId(lookUpUtils lookUpUtils){
        Integer id = lookUpUtils.getId();
        String fieldName = lookUpUtils.getFieldName();
        String fieldResult = repairBookMapp.lookUpId(id,fieldName);
        return fieldResult;
    }
    /*按照ID，修改某一个字段的值*/
    @Override
    public void repairModifyById(repairBookPojo repairBookPojo){
        log.info(repairBookPojo.toString());
        repairBookPojo.setUpdateTime(LocalDateTime.now());
        repairBookMapp.update(repairBookPojo);
    }
    /*插入一个新的步骤*/
    @Override
    public void addStep(repairBookPojo repairBookPojo){
        //合成最终数据，需要补齐创建时间，修改时间。
        repairBookPojo.setUpdateTime(LocalDateTime.now());
        repairBookPojo.setEstablishTime(LocalDateTime.now());
        log.info(repairBookPojo.toString());
        repairBookMapp.addStep(repairBookPojo);
    }
    /*接收前端的删除命令，对操作步骤进行删除*/
    @Override
    public void repairDelete(repairBookPojo repairBookPojo) {
        //删除数据库中的记录
        repairBookMapp.repairDelete(repairBookPojo.getId());
        //删除对应的文件
        String fileNameAllOld=repairBookPojo.getFileNameAll();
        if (fileNameAllOld!=null){
            if (fileNameAllOld!=""){
                String[] deleteFileItem=fileNameAllOld.split("\\|\\*\\|");
                log.info(Arrays.toString(deleteFileItem));
                //循环，对需要删除的文件进行删除。
                for (int i = 0; i < deleteFileItem.length; i++) {
                    // 构建文件的完整路径
                    String filePath = fileSaveLocation + File.separator + deleteFileItem[i];
                    //创建需要删除的这个文件
                    File file = new File(filePath);
                    //检查文件是否存在,存在的时候进行操作，不存在就不处理了
                    if(file.exists()){
                        log.info("文件找到了");
                        // 检查是否是文件而不是目录，如果是目录，就不处理了。
                        if (file.isFile()) {
                            // 检查是否有删除权限,有修改权限的时候才进行删除，没有权限就不处理了
                            if (file.canWrite()) {
                                log.info("文件有修改权限");
                                //删除文件
                                boolean isDeleted = file.delete();
                                if (isDeleted) {
                                    log.info("删除成功，文件名是：{}",filePath);
                                } else {
                                    log.info("删除识别，需要删除的文件是：{}",filePath);
                                }
                            }
                        }
                    }
                }
            }
        }

    }
    /*前端输入一组数据，进行添加到数据库中*/
    @Override
    @Transactional//开启事务，进行事务管理
    public void addFile(List<repairBookPojo> repairBookPojos){
//遍历传来的数据，对数据进行加入数据库
        for (int i = 0; i < repairBookPojos.size(); i++) {
            //组合创建时间
            repairBookPojos.get(i).setUpdateTime(LocalDateTime.now());
            repairBookPojos.get(i).setEstablishTime(LocalDateTime.now());
            //调用Mapp接口，对数据进行写入
            repairBookMapp.addStep(repairBookPojos.get(i));
        }
        //对repairTesting数据库进行写入。
        repairTestingMapp.addNew(repairBookPojos.get(0).getWorkshopEnglish(),repairBookPojos.get(0).getTaksNameEnglish(),repairBookPojos.get(0).getUpdateTime(),repairBookPojos.get(0).getEstablishTime());
    }
    @Override
    /*用在前端调整作业指导书步骤后，进行数据修改保存*/
    public void editUseOrder(List<repairBookPojo> repairBookPojos){
        //遍历，组成新的修改时间，并且根据Id，修改数据
        for (int i = 0; i < repairBookPojos.size(); i++) {
            //组成新的修改时间
            repairBookPojos.get(i).setUpdateTime(LocalDateTime.now());
            repairBookMapp.update(repairBookPojos.get(i));
        }


    }
}
